$ echo '(fn)' | clj-kondo --lint -
<stdin>:0:0: error: can't parse <stdin>, No implementation of method: :sexpr of protocol: #'rewrite-clj.node.protocols/Node found for class: nil
linting took 3ms, errors: 1, warnings: 0

$ echo '(doseq [send [inc]] (send 1))' | clj-kondo --lint -
<stdin>:1:21: error: wrong number of args (1) passed to clojure.core/send

> clj-kondo --lint . | tail -1
linting took 12508ms, errors: 11, warnings: 122
> clj-kondo --lint "$(lein classpath)" | tail -1
linting took 45004ms, errors: 268, warnings: 487
> lein clj-kondo --lint . | tail -1
linting took 9267ms, errors: 0, warnings: 0
> lein clj-kondo --lint "$(lein classpath)" | tail -1
linting took 23855ms, errors: 0, warnings: 306

{:tag :a, :attrs {:href "/cdn-cgi/l/email-protection", :class "__cf_email__", :data-cfemail "e3a18c918887968786a38e8a808b8a868f"}, :content ("[email protected]")}

(deftest two-cases
  (let [resource (load-some-resource)]
    (let [result (do-something resource)]
      (is (= 2 (count result))))
    (let [result (do-something-else resource)]
      (is (= 3 (count result))))))

(deftest two-cases
  (let [resource (load-some-resource)
        result (do-something resource)
        _ (is (= 2 (count result)))
        result (do-something-else resource)]
    (is (= 3 (count result)))))

(ns foo
  (:require
    [honeysql-postgres.format]))

(ns example
  {:clj-kondo/config
   {:linters {:unused-namespace {:exclude ['clojure.string]}}}}
  (:require [clojure.string]))

dotspacemacs-additional-packages '(flycheck-clj-kondo flycheck-joker)

;; setup clojure linters
  (use-package clojure-mode
    :ensure t
    :config
    (require 'flycheck-joker)
    (require 'flycheck-clj-kondo)
    (dolist (checkers '((clj-kondo-clj . clojure-joker)
                        (clj-kondo-cljs . clojurescript-joker)
                        (clj-kondo-cljc . clojure-joker)))
      (flycheck-add-next-checker (car checkers) (cons 'error (cdr checkers)))))

{:linters
  {:unused-namespace
    {:exclude ["cljsjs\\..*"]}}}

(try
  (let [[_ _] :foo] true)
  (catch Exception e
    false))

src/cljfmt/core.cljc:13:19: warning: namespace cljs.reader is required but never used
src/cljfmt/core.cljc:285:8: warning: unused binding sym
src/cljfmt/core.cljc:285:12: warning: unused binding alias-map
src/cljfmt/core.cljc:285:30: warning: unused binding args
linting took 77ms, errors: 0, warnings: 7

./test/main/atlas/s3_test.clj:8:2: error: unresolved symbol use-fixtures
./test/main/atlas/s3_test.clj:9:4: error: unresolved symbol compose-fixtures
./test/main/atlas/s3_test.clj:16:2: error: unresolved symbol deftest

(ns atlas.s3-test
  (:require ...
            [clojure.test :refer :all]
           ...))

(use-fixtures :once
...

(deftest lint
  (let [result (clj-kondo/run! {:lint ["src/clj" "src/cljs" "src/cljc"]})
        {:keys [error warning]} (:summary result)
        ok? (= 0 error warning)]
    (is ok? "No lint warnings")
    (when-not ok?
      (clj-kondo/print! result))))

(ns metrics-server.gitlab-fetcher
  (:require [clj-http.client :as client]
            [clojure.string :as str]
            [clojure.data.json :as json])
  (:import java.time.ZoneId
           java.time.format.DateTimeFormatter
           java.time.temporal.TemporalAdjusters
           java.time.LocalDate
           java.time.DayOfWeek))

(def zone-id (. ZoneId systemDefault))
(def formatter (. DateTimeFormatter ISO_OFFSET_DATE_TIME))
(defn date-to-string [date-time]
  (-> date-time
      (. atStartOfDay)
      (. atZone zone-id)
      (. format formatter)))
(def last-monday
  (-> (. LocalDate now)
      (. with (. TemporalAdjusters previousOrSame DayOfWeek/MONDAY))))
(def before-last-monday
  (-> last-monday
      (. with (. TemporalAdjusters previous DayOfWeek/MONDAY))))
(def before-before-last-monday
  (-> before-last-monday
      (. with (. TemporalAdjusters previous DayOfWeek/MONDAY))))

src/metrics_server/gitlab_fetcher.clj:11:17: error: unresolved symbol ZoneId
src/metrics_server/gitlab_fetcher.clj:11:24: error: unresolved symbol systemDefault
src/metrics_server/gitlab_fetcher.clj:12:19: error: unresolved symbol DateTimeFormatter
src/metrics_server/gitlab_fetcher.clj:12:37: error: unresolved symbol ISO_OFFSET_DATE_TIME
src/metrics_server/gitlab_fetcher.clj:15:10: error: unresolved symbol atStartOfDay
src/metrics_server/gitlab_fetcher.clj:16:10: error: unresolved symbol atZone
src/metrics_server/gitlab_fetcher.clj:19:10: error: unresolved symbol LocalDate
src/metrics_server/gitlab_fetcher.clj:19:20: error: unresolved symbol now
src/metrics_server/gitlab_fetcher.clj:20:10: error: unresolved symbol with
src/metrics_server/gitlab_fetcher.clj:20:18: error: unresolved symbol TemporalAdjusters
src/metrics_server/gitlab_fetcher.clj:20:36: error: unresolved symbol previousOrSame
src/metrics_server/gitlab_fetcher.clj:23:36: error: unresolved symbol previous

(defn extract-relevant-fields [{:keys [key name]
                                [{:keys [value]}] :measures}]
  {:key key
   :name name
   :value value})

src/metrics_server/complexity.clj:7:11: error: unresolved symbol value

(defn extract-relevant-fields [{{:keys [additions deletions]} :stats}]
  {:additions additions
   :deletions deletions})

src/metrics_server/churn.clj:4:15: error: unresolved symbol additions
src/metrics_server/churn.clj:5:15: error: unresolved symbol deletions

(ns foo
  (:require [clojure.string :as str]
            #?(:cljs [cljs.reader :as reader])))

(defmulti testmulti (fn [m & _] m))
(defmethod testmulti :some
  ([_] "zero arity")
  ([_ _] "unary")
  ([_ _ _] "binary"))

(defmacro testmacro
  [symbol]
  `(def ~symbol 11))

(testmacro eleven)

{:lint-as {foo/testmacro clojure.core/def}}

src\fastmath\regression.clj:98:25: info: unresolved symbol ols
src\fastmath\regression.clj:100:25: info: unresolved symbol rls
src\fastmath\regression.clj:102:25: info: unresolved symbol lasso
src\fastmath\regression.clj:102:39: info: unresolved symbol lambda
src\fastmath\regression.clj:102:46: info: unresolved symbol tolerance
src\fastmath\regression.clj:102:56: info: unresolved symbol max-iters
src\fastmath\regression.clj:108:25: info: unresolved symbol ridge
...

{:linters {:unresolved-symbol {:exclude [(wrap-regression)]}}}

$ clj-kondo --lint /tmp/foo.edn
/tmp/foo.edn:1:7: error: duplicate key :a
linting took 13ms, errors: 1, warnings: 0

$ clj-kondo --lint /tmp/foo.edn
/tmp/foo.edn:1:2: info: unresolved symbol a
/tmp/foo.edn:1:6: info: unresolved symbol b
linting took 10ms, errors: 0, warnings: 0

$ clj-kondo --lint  src/test/.clj-kondo/config.edn
src/test/.clj-kondo/config.edn:0:0: error: can't parse src/test/.clj-kondo/config.edn, Unexpected EOF. [at line 5, column 1]

{:linters {


    :invalid-arity {:level :error

~ » curl -sO 
chmod +x install-clj-kondo
./install-clj-kondo
Downloading 
------------------------------------------------------------
~ » ll /usr/local/bin | grep kondo  
------------------------------------------------------------
~ »    

(defn parse-next
  [#?(:cljs ^not-native reader :default reader)]
  (reader/read-with-meta reader parse-next*))

(defn- string-of?
  [#?(:clj ^String s :default s) pred]
  (and s
       (string? s)
       (pos? (count s))
       (every? pred s)))

(defmacro import-fn
  "Given a function in another namespace, defines a function with the
   same name in the current namespace.  Argument lists, doc-strings,
   and original line-numbers are preserved."
  [src-sym target-name target-meta]
  (let [vr (resolve-sym src-sym)
        m (meta vr)
        m (resolve-fn-location m)
        new-meta (dissoc target-meta :name)
        protocol (:protocol m)]
    (when (:macro m)
      (throw (ex-info "potemkin clj cannot import-fn on a macro" {:symbol src-sym})))
    `(do
       (def ~(with-meta target-name (if protocol {:protocol protocol} {})) (deref ~vr))
       (alter-meta! (var ~target-name) merge '~new-meta)
       ~vr)))

(ns forborkdude
  #?(:cljs (:require-macros [forborkdude :refer [my-macro]])))

#?(:clj
   (defmacro my-macro[x]
     `(str "hello there, " ~x)))

(my-macro "borkdude")

(deftest t-for-borkdude
  (are [?a ?b]
      (is (= ?a (dec ?b)))
    1 2
    10 11
    14 15))

{:linters
 {:unresolved-symbol
  {:exclude [(cljs.test/are)
             (cljs.test/is [thrown-with-msg?])]}}}

(defn fun {:ignore-vars '[arg1 arg2]} 
  [arg1 arg2])

#!/usr/bin/env bash

## turn off some joker features, so I can test clj-kondo better

/usr/local/bin/joker "

(defn fun {:ignore-vars '[arg1 arg2]} 
  [arg1 arg2])

(defmacro deftest
  {:clj-kondo/binds-globally '[test-name]}
  [test-name & cases])

(ns ^{:clj-kondo/config '{:lint-as {foo/foo clojure.core/def}}} foo)
(defmacro foo [_name & _body] ,,,)
(foo x)
(x 1)

(ns wo)

(with-open [out ( "/tmp/remove.this.txt")]
  (.write out 65))

wo.cljc:3:2: info: unresolved symbol with-open
wo.cljc:3:13: info: unresolved symbol out
linting took 48ms, errors: 0, warnings: 0

:not-empty? false

:not-empty? {:level :off}

:output {:include-files ["./src" "./test" "./modules"]}

There is a new rule :unused-keys (defaults to true) which applies to :keys, :strs, and :syms bindings.

{:linters {:unused-binding {:destructured-fn-args false}}} ;; defaults to true

(defmulti render (fn [page-type _route-params _cache-bundle] page-type))

(defmethod render :default
  [page-type _ _]
  (format "%s not implemented, sorry" page-type))

{:linters {:unused-binding {:destructured-fn-args false}}} ;; defaults to true

{:linters {:unused-binding {:exclude-destructured-fn-args false}}} ;; defaults to true

{:linters {:unused-binding {:exclude-destructured-key-fn-args false}}}

user=> (defn main [& [a b c & _ :as args]])
#'user/main
user=> (doc main)
-------------------------
user/main
([& [a b c & _ :as args]])

(defn print-coordinates-3 [[x y z]]
  (println "x:" x ", y:" y "))

Execution error (IOException) at java.lang.ProcessImpl/forkAndExec (ProcessImpl.java:-2).
error=2, No such file or directory

{:col 1,
 :filename "src/augistints/core.cljc",
 :name augistints.core,
 :row 1}

(with-redefs [clojure.core/identity (fn [_argument] 42)])

❯ echo '(defn foo [_x] _x)' | clj-kondo --lint -

(ns false-positive.reproduction-test
  (:require [clojure.test :refer (are deftest)]))

(deftest missing-test-assertion-false-positive
  (are [v expected?] (expected? (contains? #{:bar :baz} v))
       :foo false?
       :bar true?
       :baz true?))

(let [x 1
      {:keys [y] :or {y x}} {:z 2}]
  y)

$ echo '(defn x [] (inc z b))' | clj-kondo --lint - 
<stdin>:1:12: error: clojure.core/inc is called with 2 args but expects 1
<stdin>:1:17: info: unresolved symbol z
<stdin>:1:19: info: unresolved symbol b

{:clj-kondo/config
   '{:linters {:redefined-var {:level :off}
               :refer-all {:level :off}}}}

(is (empty? (lint! "(ns ^{:clj-kondo/config
                            '{:linters {:unused-namespace {:exclude [bar]}}}}
                          foo
                        (:require [bar :as b]))"))))

FAIL in (extract-clojure-core-vars-test) (extract_var_info_test.clj:12)
expected: (contains? vars (quote future))
  actual: (not (contains? #{} future))

FAIL in (extract-clojure-core-vars-test) (extract_var_info_test.clj:13)
expected: (contains? vars (quote transduce))
  actual: (not (contains? #{} transduce))

FAIL in (extract-cljs-core-vars-test) (extract_var_info_test.clj:17)
expected: (contains? vars (quote clj->js))
  actual: (not (contains? #{*target* ns js*} clj->js))

FAIL in (extract-cljs-core-vars-test) (extract_var_info_test.clj:18)
expected: (contains? vars (quote transduce))
  actual: (not (contains? #{*target* ns js*} transduce))

(ns foo
  (:refer-clojure :exclude [+ -])
  (:require [clojure.core :as c]))

(defn + [a b]
  (c/+ a b))

(prn (+ 1 2))

(is (empty? (lint! "(ns ^{:clj-kondo/config
                            '{:linters {:unused-namespace {:exclude [bar]}}}}
                          foo
                        (:require [bar :as b]))")))

(is (empty? (lint! "(ns ^{:clj-kondo/config
                            '{:debug true
                              :linters {:unused-namespace {:level :off}}}}
                          foo
                        (:require [bar :as b]))")))

(let [x 10 ;; x raises lint warning here
       ]
  (matcha/construct ?s [[?s ?p x]])

(matcha/construct {:grafter.rdf/uri ?ds
                          ?p ?o}
                         [[catalog-uri dcat:dataset ?ds]
                          [?ds ?p ?o]])

(matcha/construct {:grafter.rdf/uri ?nav-item ?nip ?nio}
                         [[nav-uri pmdui:hasNavItem ?nav-item]
                          [?nav-item ?nip ?nio]
                          (optional [[nav-uri pmdui:hasDisplayContext ?disp]])]
                         matcha-db)

{:tag :a, :attrs {:href "/cdn-cgi/l/email-protection", :class "__cf_email__", :data-cfemail "60020f120b04150405202d222152505155"}, :content ("[email protected]")}

(defmacro my-defn
  {:clj-kondo/lint-as `defn}
  ...)

clj-kondo --lint - --lang clj --cache < /Users/rick/repos/project/src/proj/routes.clj
WARNING: --cache option didn't specify directory, but no .clj-kondo directory found. Continuing without cache. See .
<stdin>:90:31: warning: unused binding imd-cfg
<stdin>:107:47: warning: unused binding decile
<stdin>:120:62: warning: unused binding params
<stdin>:136:44: warning: unused binding imd-cfg
linting took 31ms, errors: 0, warnings: 4

clj-kondo --version
clj-kondo v2019.08.21-alpha

{:tag :a, :attrs {:href "/cdn-cgi/l/email-protection", :class "__cf_email__", :data-cfemail "51333e233a35243534111c130163616068"}, :content ("[email protected]")}

$ echo '(subs "foo" "bar")' | clj-kondo --lint -
<stdin>:1:13: error: Expected a natural integer but received a string.